home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / z80gb / opc_main.h < prev    next >
Text File  |  2000-01-08  |  28KB  |  1,555 lines
  1. #define    INC_8BIT(x) \
  2. { \
  3.   register UINT8 r,f; \
  4.   x++; \
  5.   r=(x);  \
  6.   f=(UINT8)(Regs.b.F&FLAG_C); \
  7.   if( r==0 )       f|=FLAG_Z; \
  8.   if( (r&0xF)==0 ) f|=FLAG_H; \
  9.   Regs.b.F=f; \
  10. }
  11.  
  12. #define    DEC_8BIT(x) \
  13. { \
  14.   register UINT8 r,f; \
  15.   x--; \
  16.   r=(x);  \
  17.   f=(UINT8)((Regs.b.F&FLAG_C)|FLAG_N); \
  18.   if( r==0 )       f|=FLAG_Z; \
  19.   if( (r&0xF)==0 ) f|=FLAG_H; \
  20.   Regs.b.F=f; \
  21. }
  22.  
  23. #define    ADD_HL_RR(x) \
  24. { \
  25.   register UINT32 r1,r2; \
  26.   register UINT8 f; \
  27.   r1=Regs.w.HL+(x); \
  28.   r2=(Regs.w.HL&0xFFF)+((x)&0xFFF); \
  29.   f=(UINT8)(Regs.b.F&FLAG_Z); \
  30.   if( r1>0xFFFF ) f|=FLAG_C; \
  31.   if( r2>0x0FFF ) f|=FLAG_H; \
  32.   Regs.w.HL=(UINT16)r1; \
  33.   Regs.b.F=f; \
  34. }
  35.  
  36. #define    ADD_A_X(x) \
  37. { \
  38.   register UINT16 r1,r2; \
  39.   register UINT8 f; \
  40.   r1=(UINT16)((Regs.b.A&0xF)+((x)&0xF)); \
  41.   r2=(UINT16)(Regs.b.A+(x)); \
  42.   Regs.b.A=(UINT8)r2; \
  43.   if( ((UINT8)r2)==0 ) f=FLAG_Z; \
  44.     else f=0; \
  45.   if( r2>0xFF ) f|=FLAG_C; \
  46.   if( r1>0xF )  f|=FLAG_H; \
  47.   Regs.b.F=f; \
  48. }
  49.  
  50. #define    SUB_A_X(x) \
  51. { \
  52.   register UINT16 r1,r2; \
  53.   register UINT8 f; \
  54.   r1=(UINT16)((Regs.b.A&0xF)-((x)&0xF)); \
  55.   r2=(UINT16)(Regs.b.A-(x)); \
  56.   Regs.b.A=(UINT8)r2; \
  57.   if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
  58.     else f=FLAG_N; \
  59.   if( r2>0xFF ) f|=FLAG_C; \
  60.   if( r1>0xF )  f|=FLAG_H; \
  61.   Regs.b.F=f; \
  62. }
  63.  
  64. /*
  65.    #define        CP_A_X(x) \
  66.    { \
  67.    register UINT16 r; \
  68.    register UINT8 f; \
  69.    r=(UINT16)(Regs.b.A-(x)); \
  70.    if( ((UINT8)r)==0 ) \
  71.    f=FLAG_N|FLAG_Z; \
  72.    else \
  73.    f=FLAG_N; \
  74.    f|=(UINT8)((r>>8)&FLAG_C); \
  75.    if( (r^Regs.b.A^(x))&0x10 ) \
  76.    f|=FLAG_H; \
  77.    Regs.b.F=f; \
  78.    }
  79.  */
  80.  
  81. #define    CP_A_X(x) \
  82. { \
  83.   register UINT16 r1,r2; \
  84.   register UINT8 f; \
  85.   r1=(UINT16)((Regs.b.A&0xF)-((x)&0xF)); \
  86.   r2=(UINT16)(Regs.b.A-(x)); \
  87.   if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
  88.     else f=FLAG_N; \
  89.   if( r2>0xFF ) f|=FLAG_C; \
  90.   if( r1>0xF )  f|=FLAG_H; \
  91.   Regs.b.F=f; \
  92. }
  93.  
  94. #define    SBC_A_X(x) \
  95. { \
  96.   register UINT16 r1,r2; \
  97.   register UINT8 f; \
  98.   r1=(UINT16)((Regs.b.A&0xF)-((x)&0xF)-((Regs.b.F&FLAG_C)?1:0)); \
  99.   r2=(UINT16)(Regs.b.A-(x)-((Regs.b.F&FLAG_C)?1:0)); \
  100.   Regs.b.A=(UINT8)r2; \
  101.   if( ((UINT8)r2)==0 ) f=FLAG_N|FLAG_Z; \
  102.     else f=FLAG_N; \
  103.   if( r2>0xFF ) f|=FLAG_C; \
  104.   if( r1>0xF )  f|=FLAG_H; \
  105.   Regs.b.F=f; \
  106. }
  107.  
  108. #define    ADC_A_X(x) \
  109. { \
  110.   register UINT16 r1,r2;  \
  111.   register UINT8 f; \
  112.   r1=(UINT16)((Regs.b.A&0xF)+((x)&0xF)+((Regs.b.F&FLAG_C)?1:0));  \
  113.   r2=(UINT16)(Regs.b.A+(x)+((Regs.b.F&FLAG_C)?1:0)); \
  114.   if( (Regs.b.A=(UINT8)r2)==0 ) f=FLAG_Z; \
  115.     else f=0; \
  116.   if( r2>0xFF )    f|=FLAG_C; \
  117.   if( r1>0xF )    f|=FLAG_H; \
  118.   Regs.b.F=f; \
  119. }
  120.  
  121. #define    AND_A_X(x) \
  122.   if( (Regs.b.A&=(x))==0 ) \
  123.     Regs.b.F=FLAG_H|FLAG_Z; \
  124.   else \
  125.     Regs.b.F=FLAG_H;
  126.     
  127. #define XOR_A_X(x) \
  128.   if( (Regs.b.A^=(x))==0 ) \
  129.     Regs.b.F=FLAG_Z; \
  130.   else \
  131.     Regs.b.F=0;
  132.  
  133. #define    OR_A_X(x) \
  134.   if( (Regs.b.A|=(x))==0 ) \
  135.     Regs.b.F=FLAG_Z; \
  136.   else \
  137.     Regs.b.F=0;
  138.  
  139.  
  140. case 0x00: /*       NOP */
  141.   break;
  142. case 0x01: /*       LD BC,n16 */
  143.   Regs.w.BC = mem_ReadWord (Regs.w.PC);
  144.   Regs.w.PC += 2;
  145.   break;
  146. case 0x02: /*       LD (BC),A */
  147.   mem_WriteByte (Regs.w.BC, Regs.b.A);
  148.   break;
  149. case 0x03: /*       INC BC */
  150.  
  151. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  152.   if (Regs.b.B == 0xFE)
  153.   {
  154.     trash_sprites (state);
  155.   }
  156. #endif
  157.   Regs.w.BC += 1;
  158.   break;
  159. case 0x04: /*       INC B */
  160.  
  161.   INC_8BIT (Regs.b.B)
  162.   break;
  163. case 0x05: /*       DEC B */
  164.  
  165.   DEC_8BIT (Regs.b.B)
  166.   break;
  167. case 0x06: /*       LD B,n8 */
  168.  
  169.   Regs.b.B = mem_ReadByte (Regs.w.PC++);
  170.   break;
  171. case 0x07: /*       RLCA */
  172.  
  173.   Regs.b.A = (UINT8) ((Regs.b.A << 1) | (Regs.b.A >> 7));
  174.   if (Regs.b.A & 1)
  175.   {
  176.     Regs.b.F = FLAG_C;
  177.   }
  178.   else
  179.   {
  180.     Regs.b.F = 0;
  181.   }
  182.   break;
  183. case 0x08: /*       LD (n16),SP */
  184.  
  185.   mem_WriteWord (mem_ReadWord (Regs.w.PC), Regs.w.SP);
  186.   Regs.w.PC += 2;
  187.   break;
  188. case 0x09: /*       ADD HL,BC */
  189.  
  190.   ADD_HL_RR (Regs.w.BC)
  191.   break;
  192. case 0x0A: /*       LD A,(BC) */
  193.  
  194.   Regs.b.A = mem_ReadByte (Regs.w.BC);
  195.   break;
  196. case 0x0B: /*       DEC BC */
  197.  
  198. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  199.   if (Regs.b.B == 0xFE)
  200.   {
  201.     trash_sprites (state);
  202.   }
  203. #endif
  204.  
  205.   Regs.w.BC -= 1;
  206.   break;
  207. case 0x0C: /*       INC C */
  208.  
  209.   INC_8BIT (Regs.b.C)
  210.   break;
  211. case 0x0D: /*       DEC C */
  212.  
  213.   DEC_8BIT (Regs.b.C)
  214.   break;
  215. case 0x0E: /*       LD C,n8 */
  216.  
  217.   Regs.b.C = mem_ReadByte (Regs.w.PC++);
  218.   break;
  219. case 0x0F: /*       RRCA */
  220.  
  221.   Regs.b.A = (UINT8) ((Regs.b.A >> 1) | (Regs.b.A << 7));
  222.   if (Regs.b.A & 0x80)
  223.   {
  224.     Regs.b.F |= FLAG_C;
  225.   }
  226.   else
  227.   {
  228.     Regs.b.F = 0;
  229.   }
  230.   break;
  231. case 0x10: /*       STOP */
  232.   break;
  233. case 0x11: /*       LD DE,n16 */
  234.  
  235.   Regs.w.DE = mem_ReadWord (Regs.w.PC);
  236.   Regs.w.PC += 2;
  237.   break;
  238. case 0x12: /*       LD (DE),A */
  239.   mem_WriteByte (Regs.w.DE, Regs.b.A);
  240.   break;
  241. case 0x13: /*       INC DE */
  242.  
  243. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  244.   if (Regs.b.D == 0xFE)
  245.   {
  246.     trash_sprites (state);
  247.   }
  248. #endif
  249.  
  250.   Regs.w.DE += 1;
  251.   break;
  252. case 0x14: /*       INC D */
  253.  
  254.   INC_8BIT (Regs.b.D)
  255.   break;
  256. case 0x15: /*       DEC D */
  257.  
  258.   DEC_8BIT (Regs.b.D)
  259.   break;
  260. case 0x16: /*       LD D,n8 */
  261.  
  262.   Regs.b.D = mem_ReadByte (Regs.w.PC++);
  263.   break;
  264. case 0x17: /*       RLA */
  265.   
  266.   x = (Regs.b.A & 0x80) ? FLAG_C : 0;
  267.  
  268.   Regs.b.A = (UINT8) ((Regs.b.A << 1) | ((Regs.b.F & FLAG_C) ? 1 : 0));
  269.   Regs.b.F = x;
  270.   break;
  271. case 0x18: /*       JR       n8 */
  272.   {
  273.     INT8 offset;
  274.  
  275.     offset = mem_ReadByte (Regs.w.PC++);
  276.     Regs.w.PC += offset;
  277.   }
  278.   break;
  279. case 0x19: /*       ADD HL,DE */
  280.  
  281.   ADD_HL_RR (Regs.w.DE)
  282.   break;
  283. case 0x1A: /*       LD A,(DE) */
  284.  
  285.   Regs.b.A = mem_ReadByte (Regs.w.DE);
  286.   break;
  287. case 0x1B: /*       DEC DE */
  288.  
  289. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  290.   if (Regs.b.D == 0xFE)
  291.   {
  292.     trash_sprites (state);
  293.   }
  294. #endif
  295.  
  296.   Regs.w.DE -= 1;
  297.   break;
  298. case 0x1C: /*       INC E */
  299.  
  300.   INC_8BIT (Regs.b.E)
  301.   break;
  302. case 0x1D: /*       DEC E */
  303.  
  304.   DEC_8BIT (Regs.b.E)
  305.   break;
  306. case 0x1E: /*       LD E,n8 */
  307.  
  308.   Regs.b.E = mem_ReadByte (Regs.w.PC++);
  309.   break;
  310. case 0x1F: /*       RRA */
  311.   
  312.   x = (Regs.b.A & 1) ? FLAG_C : 0;
  313.  
  314.   Regs.b.A = (UINT8) ((Regs.b.A >> 1) | ((Regs.b.F & FLAG_C) ? 0x80 : 0));
  315.   Regs.b.F = x;
  316.   break;
  317. case 0x20: /*       JR NZ,n8 */
  318.  
  319.   if (Regs.b.F & FLAG_Z)
  320.   {
  321.     Regs.w.PC++;
  322.   }
  323.   else
  324.   {
  325.     INT8 offset;
  326.  
  327.     offset = mem_ReadByte (Regs.w.PC++);
  328.     Regs.w.PC += offset;
  329.     ICycles += 4;
  330.   }
  331.   break;
  332. case 0x21: /*       LD HL,n16 */
  333.  
  334.   Regs.w.HL = mem_ReadWord (Regs.w.PC);
  335.   Regs.w.PC += 2;
  336.   break;
  337. case 0x22: /*       LD (HL+),A */
  338.  
  339. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  340.   if (Regs.b.H == 0xFE)
  341.   {
  342.     trash_sprites (state);
  343.   }
  344. #endif
  345.  
  346.   mem_WriteByte (Regs.w.HL, Regs.b.A);
  347.   Regs.w.HL += 1;
  348.   break;
  349. case 0x23: /*       INC HL */
  350.  
  351. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  352.   if (Regs.b.H == 0xFE)
  353.   {
  354.     trash_sprites (state);
  355.   }
  356. #endif
  357.  
  358.   Regs.w.HL += 1;
  359.   break;
  360. case 0x24: /*       INC H */
  361.  
  362.   INC_8BIT (Regs.b.H);
  363.   break;
  364. case 0x25: /*       DEC H */
  365.  
  366.   DEC_8BIT (Regs.b.H);
  367.   break;
  368. case 0x26: /*       LD H,n8 */
  369.  
  370.   Regs.b.H = mem_ReadByte (Regs.w.PC++);
  371.   break;
  372. case 0x27: /*       DAA */
  373.  
  374.   Regs.w.AF = DAATable[(((UINT16) (Regs.b.F & (FLAG_N | FLAG_C | FLAG_H))) << 4) | Regs.b.A];
  375.   break;
  376. case 0x28: /*       JR Z,n8 */
  377.  
  378.   if (Regs.b.F & FLAG_Z)
  379.   {
  380.     INT8 offset;
  381.  
  382.     offset = mem_ReadByte (Regs.w.PC++);
  383.     Regs.w.PC += offset;
  384.  
  385.     ICycles += 4;
  386.   }
  387.   else
  388.   {
  389.     Regs.w.PC += 1;
  390.   }
  391.   break;
  392. case 0x29: /*       ADD HL,HL */
  393.  
  394.   ADD_HL_RR (Regs.w.HL)
  395.   break;
  396. case 0x2A: /*       LD A,(HL+) */
  397. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  398.   if (Regs.b.H == 0xFE)
  399.   {
  400.     trash_sprites (state);
  401.   }
  402. #endif
  403.  
  404.   Regs.b.A = mem_ReadByte (Regs.w.HL);
  405.   Regs.w.HL += 1;
  406.   break;
  407. case 0x2B: /*       DEC HL */
  408.  
  409. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  410.   if (Regs.b.H == 0xFE)
  411.   {
  412.     trash_sprites (state);
  413.   }
  414. #endif
  415.  
  416.   Regs.w.HL -= 1;
  417.   break;
  418. case 0x2C: /*       INC L */
  419.  
  420.   INC_8BIT (Regs.b.L);
  421.   break;
  422. case 0x2D: /*       DEC L */
  423.  
  424.   DEC_8BIT (Regs.b.L);
  425.   break;
  426. case 0x2E: /*       LD L,n8 */
  427.  
  428.   Regs.b.L = mem_ReadByte (Regs.w.PC++);
  429.   break;
  430. case 0x2F: /*       CPL */
  431.  
  432.   Regs.b.A = ~Regs.b.A;
  433.   Regs.b.F |= FLAG_N | FLAG_H;
  434.   return 4;
  435.   break;
  436. case 0x30: /*       JR NC,n8 */
  437.  
  438.   if (Regs.b.F & FLAG_C)
  439.   {
  440.     Regs.w.PC += 1;
  441.   }
  442.   else
  443.   {
  444.     INT8 offset;
  445.  
  446.     offset = mem_ReadByte (Regs.w.PC++);
  447.     Regs.w.PC += offset;
  448.     ICycles += 4;
  449.   }
  450.   break;
  451. case 0x31: /*       LD SP,n16 */
  452.  
  453.   Regs.w.SP = mem_ReadWord (Regs.w.PC);
  454.   Regs.w.PC += 2;
  455.   break;
  456. case 0x32: /*       LD (HL-),A */
  457.  
  458. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  459.   if (Regs.b.H == 0xFE)
  460.   {
  461.     trash_sprites (state);
  462.   }
  463. #endif
  464.  
  465.   mem_WriteByte (Regs.w.HL, Regs.b.A);
  466.   Regs.w.HL -= 1;
  467.   break;
  468. case 0x33: /*       INC SP */
  469.  
  470.   Regs.w.SP += 1;
  471.   break;
  472. case 0x34: /*       INC (HL) */
  473.   
  474.   {
  475.     register UINT8 r, f;
  476.  
  477.     f = (UINT8) (Regs.b.F & FLAG_C);
  478.     r = (UINT8) (mem_ReadByte (Regs.w.HL) + 1);
  479.     mem_WriteByte (Regs.w.HL, r);
  480.  
  481.     if (r == 0)
  482.       f |= FLAG_Z;
  483.  
  484.     if ((r & 0xF) == 0)
  485.       f |= FLAG_H;
  486.  
  487.     Regs.b.F = f;
  488.   }
  489.   break;
  490. case 0x35: /*       DEC (HL) */
  491.   
  492.   {
  493.     register UINT8 r, f;
  494.  
  495.     f = (UINT8) ((Regs.b.F & FLAG_C) | FLAG_N);
  496.     r = (UINT8) (mem_ReadByte (Regs.w.HL) - 1);
  497.     mem_WriteByte (Regs.w.HL, r);
  498.  
  499.     if (r == 0)
  500.       f |= FLAG_Z;
  501.  
  502.     if ((r & 0xF) != 0xF)
  503.       f |= FLAG_H;
  504.  
  505.     Regs.b.F = f;
  506.   }
  507.   break;
  508. case 0x36: /*       LD (HL),n8 */
  509.   /* FIXED / broken ? */
  510.   mem_WriteByte (Regs.w.HL, mem_ReadByte (Regs.w.PC++));
  511.   break;
  512. case 0x37: /*       SCF */
  513.  
  514.   Regs.b.F = (UINT8) ((Regs.b.F & FLAG_Z) | FLAG_C);
  515.   break;
  516. case 0x38: /*       JR C,n8 */
  517.  
  518.   if (Regs.b.F & FLAG_C)
  519.   {
  520.     INT8 offset;
  521.  
  522.     offset = mem_ReadByte (Regs.w.PC++);
  523.     Regs.w.PC += offset;
  524.  
  525.     ICycles += 4;
  526.   }
  527.   else
  528.   {
  529.     Regs.w.PC += 1;
  530.   }
  531.   break;
  532. case 0x39: /*       ADD HL,SP */
  533.   ADD_HL_RR (Regs.w.SP)
  534.   break;
  535. case 0x3A: /*       LD A,(HL-) */
  536. #if 0                /* FIXME ?? do we want to support this? (bug emulation) */
  537.   if (Regs.b.H == 0xFE)
  538.   {
  539.     trash_sprites (state);
  540.   }
  541. #endif
  542.  
  543.   Regs.b.A = mem_ReadByte (Regs.w.HL);
  544.   Regs.w.HL -= 1;
  545.   break;
  546. case 0x3B: /*       DEC SP */
  547.  
  548.   Regs.w.SP -= 1;
  549.   break;
  550. case 0x3C: /*       INC       A */
  551.  
  552.   INC_8BIT (Regs.b.A);
  553.   break;
  554. case 0x3D: /*       DEC       A */
  555.  
  556.   DEC_8BIT (Regs.b.A);
  557.   break;
  558. case 0x3E: /*       LD A,n8 */
  559.  
  560.   Regs.b.A = mem_ReadByte (Regs.w.PC++);
  561.   break;
  562. case 0x3F: /*       CCF */
  563.  
  564.   Regs.b.F = (UINT8) ((Regs.b.F & FLAG_Z) | ((Regs.b.F & FLAG_C) ? 0 : FLAG_C));
  565.   break;
  566. case 0x40: /*       LD B,B */
  567.   break;
  568. case 0x41: /*       LD B,C */
  569.  
  570.   Regs.b.B = Regs.b.C;
  571.   break;
  572. case 0x42: /*       LD B,D */
  573.  
  574.   Regs.b.B = Regs.b.D;
  575.   break;
  576. case 0x43: /*       LD B,E */
  577.  
  578.   Regs.b.B = Regs.b.E;
  579.   break;
  580. case 0x44: /*       LD B,H */
  581.  
  582.   Regs.b.B = Regs.b.H;
  583.   break;
  584. case 0x45: /*       LD B,L */
  585.  
  586.   Regs.b.B = Regs.b.L;
  587.   break;
  588. case 0x46: /*       LD B,(HL) */
  589.  
  590.   Regs.b.B = mem_ReadByte (Regs.w.HL);
  591.   break;
  592. case 0x47: /*       LD B,A */
  593.  
  594.   Regs.b.B = Regs.b.A;
  595.   break;
  596. case 0x48: /*       LD C,B */
  597.  
  598.   Regs.b.C = Regs.b.B;
  599.   break;
  600. case 0x49: /*       LD C,C */
  601.   break;
  602. case 0x4A: /*       LD C,D */
  603.  
  604.   Regs.b.C = Regs.b.D;
  605.   break;
  606. case 0x4B: /*       LD C,E */
  607.  
  608.   Regs.b.C = Regs.b.E;
  609.   break;
  610. case 0x4C: /*       LD C,H */
  611.  
  612.   Regs.b.C = Regs.b.H;
  613.   break;
  614. case 0x4D: /*       LD C,L */
  615.  
  616.   Regs.b.C = Regs.b.L;
  617.   break;
  618. case 0x4E: /*       LD C,(HL) */
  619.  
  620.   Regs.b.C = mem_ReadByte (Regs.w.HL);
  621.   break;
  622. case 0x4F: /*       LD C,A */
  623.  
  624.   Regs.b.C = Regs.b.A;
  625.   break;
  626. case 0x50: /*       LD D,B */
  627.  
  628.   Regs.b.D = Regs.b.B;
  629.   break;
  630. case 0x51: /*       LD D,C */
  631.  
  632.   Regs.b.D = Regs.b.C;
  633.   break;
  634. case 0x52: /*       LD D,D */
  635.   break;
  636. case 0x53: /*       LD D,E */
  637.  
  638.   Regs.b.D = Regs.b.E;
  639.   break;
  640. case 0x54: /*       LD D,H */
  641.  
  642.   Regs.b.D = Regs.b.H;
  643.   break;
  644. case 0x55: /*       LD D,L */
  645.  
  646.   Regs.b.D = Regs.b.L;
  647.   break;
  648. case 0x56: /*       LD D,(HL) */
  649.  
  650.   Regs.b.D = mem_ReadByte (Regs.w.HL);
  651.   break;
  652. case 0x57: /*       LD D,A */
  653.  
  654.   Regs.b.D = Regs.b.A;
  655.   break;
  656. case 0x58: /*       LD E,B */
  657.  
  658.   Regs.b.E = Regs.b.B;
  659.   break;
  660. case 0x59: /*       LD E,C */
  661.  
  662.   Regs.b.E = Regs.b.C;
  663.   break;
  664. case 0x5A: /*       LD E,D */
  665.  
  666.   Regs.b.E = Regs.b.D;
  667.   break;
  668. case 0x5B: /*       LD E,E */
  669.   break;
  670. case 0x5C: /*       LD E,H */
  671.  
  672.   Regs.b.E = Regs.b.H;
  673.   break;
  674. case 0x5D: /*       LD E,L */
  675.  
  676.   Regs.b.E = Regs.b.L;
  677.   break;
  678. case 0x5E: /*       LD E,(HL) */
  679.  
  680.   Regs.b.E = mem_ReadByte (Regs.w.HL);
  681.   break;
  682. case 0x5F: /*       LD E,A */
  683.  
  684.   Regs.b.E = Regs.b.A;
  685.   break;
  686. case 0x60: /*       LD H,B */
  687.  
  688.   Regs.b.H = Regs.b.B;
  689.   break;
  690. case 0x61: /*       LD H,C */
  691.  
  692.   Regs.b.H = Regs.b.C;
  693.   break;
  694. case 0x62: /*       LD H,D */
  695.  
  696.   Regs.b.H = Regs.b.D;
  697.   break;
  698. case 0x63: /*       LD H,E */
  699.  
  700.   Regs.b.H = Regs.b.E;
  701.   break;
  702. case 0x64: /*       LD H,H */
  703.   break;
  704. case 0x65: /*       LD H,L */
  705.  
  706.   Regs.b.H = Regs.b.L;
  707.   break;
  708. case 0x66: /*       LD H,(HL) */
  709.  
  710.   Regs.b.H = mem_ReadByte (Regs.w.HL);
  711.   break;
  712. case 0x67: /*       LD H,A */
  713.  
  714.   Regs.b.H = Regs.b.A;
  715.   break;
  716. case 0x68: /*       LD L,B */
  717.  
  718.   Regs.b.L = Regs.b.B;
  719.   break;
  720. case 0x69: /*       LD L,C */
  721.  
  722.   Regs.b.L = Regs.b.C;
  723.   break;
  724. case 0x6A: /*       LD L,D */
  725.   Regs.b.L = Regs.b.D;
  726.   break;
  727. case 0x6B: /*       LD L,E */
  728.  
  729.   Regs.b.L = Regs.b.E;
  730.   break;
  731. case 0x6C: /*       LD L,H */
  732.  
  733.   Regs.b.L = Regs.b.H;
  734.   break;
  735. case 0x6D: /*       LD L,L */
  736.   break;
  737. case 0x6E: /*       LD L,(HL) */
  738.  
  739.   Regs.b.L = mem_ReadByte (Regs.w.HL);
  740.   break;
  741. case 0x6F: /*       LD L,A */
  742.  
  743.   Regs.b.L = Regs.b.A;
  744.   break;
  745. case 0x70: /*       LD (HL),B */
  746.  
  747.   mem_WriteByte (Regs.w.HL, Regs.b.B);
  748.   break;
  749. case 0x71: /*       LD (HL),C */
  750.  
  751.   mem_WriteByte (Regs.w.HL, Regs.b.C);
  752.   break;
  753. case 0x72: /*       LD (HL),D */
  754.  
  755.   mem_WriteByte (Regs.w.HL, Regs.b.D);
  756.   break;
  757. case 0x73: /*       LD (HL),E */
  758.  
  759.   mem_WriteByte (Regs.w.HL, Regs.b.E);
  760.   break;
  761. case 0x74: /*       LD (HL),H */
  762.  
  763.   mem_WriteByte (Regs.w.HL, Regs.b.H);
  764.   break;
  765. case 0x75: /*       LD (HL),L */
  766.  
  767.   mem_WriteByte (Regs.w.HL, Regs.b.L);
  768.   break;
  769. case 0x76: /*       HALT */
  770.   {
  771.     UINT32 skip_cycles;
  772.     Regs.w.enable |= HALTED;
  773.     CheckInterrupts = 1;
  774.     Regs.w.PC--;
  775.     
  776.     /* Calculate nr of cycles which can be skipped */
  777.     skip_cycles = (0x100 << gb_timer_shift) - gb_timer_count;
  778.     if (skip_cycles > z80gb_ICount) skip_cycles = z80gb_ICount;
  779.     
  780.     /* round cycles to multiple of 4 always round upwards */
  781.     skip_cycles = (skip_cycles+3) & ~3;
  782.     if (skip_cycles > ICycles) ICycles += skip_cycles - ICycles;
  783.   }
  784.   break;
  785. case 0x77: /*       LD (HL),A */
  786.  
  787.   mem_WriteByte (Regs.w.HL, Regs.b.A);
  788.   break;
  789. case 0x78: /*       LD A,B */
  790.  
  791.   Regs.b.A = Regs.b.B;
  792.   break;
  793. case 0x79: /*       LD A,C */
  794.  
  795.   Regs.b.A = Regs.b.C;
  796.   break;
  797. case 0x7A: /*       LD A,D */
  798.  
  799.   Regs.b.A = Regs.b.D;
  800.   break;
  801. case 0x7B: /*       LD A,E */
  802.  
  803.   Regs.b.A = Regs.b.E;
  804.   break;
  805. case 0x7C: /*       LD A,H */
  806.  
  807.   Regs.b.A = Regs.b.H;
  808.   break;
  809. case 0x7D: /*       LD A,L */
  810.  
  811.   Regs.b.A = Regs.b.L;
  812.   break;
  813. case 0x7E: /*       LD A,(HL) */
  814.  
  815.   Regs.b.A = mem_ReadByte (Regs.w.HL);
  816.   break;
  817. case 0x7F: /*       LD A,A */
  818.   break;
  819. case 0x80: /*       ADD A,B */
  820.  
  821.   ADD_A_X (Regs.b.B)
  822.   break;
  823. case 0x81: /*       ADD A,C */
  824.  
  825.   ADD_A_X (Regs.b.C)
  826.   break;
  827. case 0x82: /*       ADD A,D */
  828.  
  829.   ADD_A_X (Regs.b.D)
  830.   break;
  831. case 0x83: /*       ADD A,E */
  832.  
  833.   ADD_A_X (Regs.b.E)
  834.   break;
  835. case 0x84: /*       ADD A,H */
  836.  
  837.   ADD_A_X (Regs.b.H)
  838.   break;
  839. case 0x85: /*       ADD A,L */
  840.  
  841.   ADD_A_X (Regs.b.L)
  842.   break;
  843. case 0x86: /*       ADD A,(HL) */
  844.  
  845.   x = mem_ReadByte (Regs.w.HL);
  846.  
  847.   ADD_A_X (x)
  848.   break;
  849. case 0x87: /*       ADD A,A */
  850.  
  851.   ADD_A_X (Regs.b.A)
  852.   break;
  853. case 0x88: /*       ADC A,B */
  854.  
  855.   ADC_A_X (Regs.b.B)
  856.   break;
  857. case 0x89: /*       ADC A,C */
  858.  
  859.   ADC_A_X (Regs.b.C)
  860.   break;
  861. case 0x8A: /*       ADC A,D */
  862.  
  863.   ADC_A_X (Regs.b.D)
  864.   break;
  865. case 0x8B: /*       ADC A,E */
  866.  
  867.   ADC_A_X (Regs.b.E)
  868.   break;
  869. case 0x8C: /*       ADC A,H */
  870.  
  871.   ADC_A_X (Regs.b.H)
  872.   break;
  873. case 0x8D: /*       ADC A,L */
  874.  
  875.   ADC_A_X (Regs.b.L)
  876.   break;
  877. case 0x8E: /*       ADC A,(HL) */
  878.  
  879.   x = mem_ReadByte (Regs.w.HL);
  880.  
  881.   ADC_A_X (x)
  882.   break;
  883. case 0x8F: /*       ADC A,A */
  884.  
  885.   ADC_A_X (Regs.b.A)
  886.   break;
  887. case 0x90: /*       SUB A,B */
  888.  
  889.   SUB_A_X (Regs.b.B)
  890.   break;
  891. case 0x91: /*       SUB A,C */
  892.  
  893.   SUB_A_X (Regs.b.C)
  894.   break;
  895. case 0x92: /*       SUB A,D */
  896.  
  897.   SUB_A_X (Regs.b.D)
  898.   break;
  899. case 0x93: /*       SUB A,E */
  900.  
  901.   SUB_A_X (Regs.b.E)
  902.   break;
  903. case 0x94: /*       SUB A,H */
  904.  
  905.   SUB_A_X (Regs.b.H)
  906.   break;
  907. case 0x95: /*       SUB A,L */
  908.  
  909.   SUB_A_X (Regs.b.L)
  910.   break;
  911. case 0x96: /*       SUB A,(HL) */
  912.  
  913.  
  914.   x = mem_ReadByte (Regs.w.HL);
  915.  
  916.   SUB_A_X (x)
  917.   break;
  918. case 0x97: /*       SUB A,A */
  919.  
  920.   SUB_A_X (Regs.b.A)
  921.   break;
  922. case 0x98: /*       SBC A,B */
  923.  
  924.   SBC_A_X (Regs.b.B)
  925.   break;
  926. case 0x99: /*       SBC A,C */
  927.  
  928.   SBC_A_X (Regs.b.C)
  929.   break;
  930. case 0x9A: /*       SBC A,D */
  931.  
  932.   SBC_A_X (Regs.b.D)
  933.   break;
  934. case 0x9B: /*       SBC A,E */
  935.  
  936.   SBC_A_X (Regs.b.E)
  937.   break;
  938. case 0x9C: /*       SBC A,H */
  939.  
  940.   SBC_A_X (Regs.b.H)
  941.   break;
  942. case 0x9D: /*       SBC A,L */
  943.  
  944.   SBC_A_X (Regs.b.L)
  945.   break;
  946. case 0x9E: /*       SBC A,(HL) */
  947.  
  948.   x = mem_ReadByte (Regs.w.HL);
  949.  
  950.   SBC_A_X (x)
  951.   break;
  952. case 0x9F: /*       SBC A,A */
  953.  
  954.   SBC_A_X (Regs.b.A)
  955.   break;
  956. case 0xA0: /*       AND A,B */
  957.  
  958.   AND_A_X (Regs.b.B)
  959.   break;
  960. case 0xA1: /*       AND A,C */
  961.  
  962.   AND_A_X (Regs.b.C)
  963.   break;
  964. case 0xA2: /*       AND A,D */
  965.  
  966.   AND_A_X (Regs.b.D)
  967.   break;
  968. case 0xA3: /*       AND A,E */
  969.  
  970.   AND_A_X (Regs.b.E)
  971.   break;
  972. case 0xA4: /*       AND A,H */
  973.  
  974.   AND_A_X (Regs.b.H)
  975.   break;
  976. case 0xA5: /*       AND A,L */
  977.  
  978.   AND_A_X (Regs.b.L)
  979.   break;
  980. case 0xA6: /*       AND A,(HL) */
  981.  
  982.   x = mem_ReadByte (Regs.w.HL);
  983.  
  984.   AND_A_X (x)
  985.   break;
  986. case 0xA7: /*       AND A,A */
  987.  
  988.   Regs.b.F = (Regs.b.A == 0) ? (FLAG_H | FLAG_Z) : FLAG_H;
  989.   break;
  990. case 0xA8: /*       XOR A,B */
  991.  
  992.   XOR_A_X (Regs.b.B)
  993.   break;
  994. case 0xA9: /*       XOR A,C */
  995.  
  996.   XOR_A_X (Regs.b.C)
  997.   break;
  998. case 0xAA: /*       XOR A,D */
  999.  
  1000.   XOR_A_X (Regs.b.D)
  1001.   break;
  1002. case 0xAB: /*       XOR A,E */
  1003.  
  1004.   XOR_A_X (Regs.b.E)
  1005.   break;
  1006. case 0xAC: /*       XOR A,H */
  1007.  
  1008.   XOR_A_X (Regs.b.H)
  1009.   break;
  1010. case 0xAD: /*       XOR A,L */
  1011.  
  1012.   XOR_A_X (Regs.b.L)
  1013.   break;
  1014. case 0xAE: /*       XOR A,(HL) */
  1015.  
  1016.   x = mem_ReadByte (Regs.w.HL);
  1017.  
  1018.   XOR_A_X (x)
  1019.   break;
  1020. case 0xAF: /*       XOR A,A */
  1021.  
  1022.   XOR_A_X (Regs.b.A)
  1023.   break;
  1024. case 0xB0: /*       OR A,B */
  1025.  
  1026.   OR_A_X (Regs.b.B)
  1027.   break;
  1028. case 0xB1: /*       OR A,C */
  1029.  
  1030.   OR_A_X (Regs.b.C)
  1031.   break;
  1032. case 0xB2: /*       OR A,D */
  1033.  
  1034.   OR_A_X (Regs.b.D)
  1035.   break;
  1036. case 0xB3: /*       OR A,E */
  1037.  
  1038.   OR_A_X (Regs.b.E)
  1039.   break;
  1040. case 0xB4: /*       OR A,H */
  1041.  
  1042.   OR_A_X (Regs.b.H)
  1043.   break;
  1044. case 0xB5: /*       OR A,L */
  1045.  
  1046.   OR_A_X (Regs.b.L)
  1047.   break;
  1048. case 0xB6: /*       OR A,(HL) */
  1049.  
  1050.   x = mem_ReadByte (Regs.w.HL);
  1051.  
  1052.   OR_A_X (x)
  1053.   break;
  1054. case 0xB7: /*       OR A,A */
  1055.  
  1056.   OR_A_X (Regs.b.A)
  1057.   break;
  1058. case 0xB8: /*       CP A,B */
  1059.  
  1060.   CP_A_X (Regs.b.B)
  1061.   break;
  1062. case 0xB9: /*       CP A,C */
  1063.  
  1064.   CP_A_X (Regs.b.C)
  1065.   break;
  1066. case 0xBA: /*       CP A,D */
  1067.  
  1068.   CP_A_X (Regs.b.D)
  1069.   break;
  1070. case 0xBB: /*       CP A,E */
  1071.  
  1072.   CP_A_X (Regs.b.E)
  1073.   break;
  1074. case 0xBC: /*       CP A,H */
  1075.  
  1076.   CP_A_X (Regs.b.H)
  1077.   break;
  1078. case 0xBD: /*       CP A,L */
  1079.  
  1080.   CP_A_X (Regs.b.L)
  1081.   break;
  1082. case 0xBE: /*       CP A,(HL) */
  1083.  
  1084.   x = mem_ReadByte (Regs.w.HL);
  1085.  
  1086.   CP_A_X (x)
  1087.   break;
  1088. case 0xBF: /*       CP A,A */
  1089.  
  1090.   CP_A_X (Regs.b.A)
  1091.   break;
  1092. case 0xC0: /*       RET NZ */
  1093.  
  1094.   if (!(Regs.b.F & FLAG_Z))
  1095.   {
  1096.     Regs.w.PC = mem_ReadWord (Regs.w.SP);
  1097.     Regs.w.SP += 2;
  1098.     ICycles += 12;
  1099.   }
  1100.   break;
  1101. case 0xC1: /*       POP BC */
  1102.  
  1103.   Regs.w.BC = mem_ReadWord (Regs.w.SP);
  1104.   Regs.w.SP += 2;
  1105.   break;
  1106. case 0xC2: /*       JP NZ,n16 */
  1107.  
  1108.   if (Regs.b.F & FLAG_Z)
  1109.   {
  1110.     Regs.w.PC += 2;
  1111.   }
  1112.   else
  1113.   {
  1114.     Regs.w.PC = mem_ReadWord (Regs.w.PC);
  1115.     ICycles += 4;
  1116.   }
  1117.   break;
  1118. case 0xC3: /*       JP n16 */
  1119.  
  1120.   Regs.w.PC = mem_ReadWord (Regs.w.PC);
  1121.   break;
  1122. case 0xC4: /*       CALL NZ,n16 */
  1123.  
  1124.   if (Regs.b.F & FLAG_Z)
  1125.   {
  1126.     Regs.w.PC += 2;
  1127.   }
  1128.   else
  1129.   {
  1130.     register UINT16 PC;
  1131.     PC = mem_ReadWord (Regs.w.PC);
  1132.     Regs.w.PC += 2;
  1133.  
  1134.     Regs.w.SP -= 2;
  1135.     mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1136.     Regs.w.PC = PC;
  1137.     ICycles += 12;
  1138.   }
  1139.   break;
  1140. case 0xC5: /*       PUSH BC */
  1141.  
  1142.   Regs.w.SP -= 2;
  1143.   mem_WriteWord (Regs.w.SP, Regs.w.BC);
  1144.   break;
  1145. case 0xC6: /*       ADD A,n8 */
  1146.  
  1147.   x = mem_ReadByte (Regs.w.PC++);
  1148.   ADD_A_X (x)
  1149.   break;
  1150. case 0xC7: /*       RST 0 */
  1151.   
  1152.   {
  1153.     register UINT16 PC;
  1154.     PC = Regs.w.PC;
  1155.     Regs.w.PC = 0;
  1156.  
  1157.     Regs.w.SP -= 2;
  1158.     mem_WriteWord (Regs.w.SP, PC);
  1159.   }
  1160.   break;
  1161. case 0xC8: /*       RET Z */
  1162.  
  1163.   if (Regs.b.F & FLAG_Z)
  1164.   {
  1165.     Regs.w.PC = mem_ReadWord (Regs.w.SP);
  1166.     Regs.w.SP += 2;
  1167.     ICycles += 12;
  1168.   }
  1169.   break;
  1170. case 0xC9: /*       RET */
  1171.  
  1172.   Regs.w.PC = mem_ReadWord (Regs.w.SP);
  1173.   Regs.w.SP += 2;
  1174.   break;
  1175. case 0xCA: /*       JP Z,n16 */
  1176.  
  1177.   if (Regs.b.F & FLAG_Z)
  1178.   {
  1179.     Regs.w.PC = mem_ReadWord (Regs.w.PC);
  1180.     ICycles += 4;
  1181.   }
  1182.   else
  1183.   {
  1184.     Regs.w.PC += 2;
  1185.   }
  1186.   break;
  1187. case 0xCB: /*       PREFIX! */
  1188.   x = mem_ReadByte (Regs.w.PC++);
  1189.   ICycles += CyclesCB[x];
  1190.   switch (x)
  1191.   {
  1192.     #include "opc_cb.h"
  1193.   }  
  1194.   break;
  1195. case 0xCC: /*       CALL Z,n16 */
  1196.  
  1197.   if (Regs.b.F & FLAG_Z)
  1198.   {
  1199.     register UINT16 PC;
  1200.     PC = mem_ReadWord (Regs.w.PC);
  1201.     Regs.w.PC += 2;
  1202.  
  1203.     Regs.w.SP -= 2;
  1204.     mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1205.     Regs.w.PC = PC;
  1206.     ICycles += 12;
  1207.   }
  1208.   else
  1209.   {
  1210.     Regs.w.PC += 2;
  1211.   }
  1212.   break;
  1213. case 0xCD: /*       CALL n16 */
  1214.   {
  1215.     register UINT16 PC;
  1216.     PC = mem_ReadWord (Regs.w.PC);
  1217.     Regs.w.PC += 2;
  1218.  
  1219.     Regs.w.SP -= 2;
  1220.     mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1221.     Regs.w.PC = PC;
  1222.   }
  1223.   break;
  1224. case 0xCE: /*       ADC A,n8 */
  1225.  
  1226.   x = mem_ReadByte (Regs.w.PC++);
  1227.   ADC_A_X (x)
  1228.   break;
  1229. case 0xCF: /*       RST 8 */
  1230.  
  1231.   Regs.w.SP -= 2;
  1232.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1233.   Regs.w.PC = 8;
  1234.   break;
  1235. case 0xD0: /*       RET NC */
  1236.  
  1237.   if (!(Regs.b.F & FLAG_C))
  1238.   {
  1239.     Regs.w.PC = mem_ReadWord (Regs.w.SP);
  1240.     Regs.w.SP += 2;
  1241.     ICycles += 12;
  1242.   }
  1243.   break;
  1244. case 0xD1: /*       POP DE */
  1245.  
  1246.   Regs.w.DE = mem_ReadWord (Regs.w.SP);
  1247.   Regs.w.SP += 2;
  1248.   break;
  1249. case 0xD2: /*       JP NC,n16 */
  1250.  
  1251.   if (Regs.b.F & FLAG_C)
  1252.   {
  1253.     Regs.w.PC += 2;
  1254.   }
  1255.   else
  1256.   {
  1257.     Regs.w.PC = mem_ReadWord (Regs.w.PC);
  1258.     ICycles += 4;
  1259.   }
  1260.   break;
  1261. case 0xD3: /*       EH? */
  1262.   break;
  1263. case 0xD4: /*       CALL NC,n16 */
  1264.  
  1265.   if (Regs.b.F & FLAG_C)
  1266.   {
  1267.     Regs.w.PC += 2;
  1268.   }
  1269.   else
  1270.   {
  1271.     register UINT16 PC;
  1272.     PC = mem_ReadWord (Regs.w.PC);
  1273.     Regs.w.PC += 2;
  1274.  
  1275.     Regs.w.SP -= 2;
  1276.     mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1277.     Regs.w.PC = PC;
  1278.     ICycles += 12;
  1279.   }
  1280.   break;
  1281. case 0xD5: /*       PUSH DE */
  1282.  
  1283.   Regs.w.SP -= 2;
  1284.   mem_WriteWord (Regs.w.SP, Regs.w.DE);
  1285.   break;
  1286. case 0xD6: /*       SUB A,n8 */
  1287.  
  1288.   x = mem_ReadByte (Regs.w.PC++);
  1289.   SUB_A_X (x)
  1290.   break;
  1291. case 0xD7: /*       RST       $10 */
  1292.  
  1293.   Regs.w.SP -= 2;
  1294.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1295.   Regs.w.PC = 0x10;
  1296.   break;
  1297. case 0xD8: /*       RET C */
  1298.  
  1299.   if (Regs.b.F & FLAG_C)
  1300.   {
  1301.     Regs.w.PC = mem_ReadWord (Regs.w.SP);
  1302.     Regs.w.SP += 2;
  1303.     ICycles += 12;
  1304.   }
  1305.   break;
  1306. case 0xD9: /*       RETI */
  1307.  
  1308.   Regs.w.PC = mem_ReadWord (Regs.w.SP);
  1309.   Regs.w.SP += 2;
  1310.   Regs.w.enable |= IME;
  1311.   CheckInterrupts = 1;
  1312.   break;
  1313. case 0xDA: /*       JP C,n16 */
  1314.  
  1315.   if (Regs.b.F & FLAG_C)
  1316.   {
  1317.     Regs.w.PC = mem_ReadWord (Regs.w.PC);
  1318.     ICycles += 4;
  1319.   }
  1320.   else
  1321.   {
  1322.     Regs.w.PC += 2;
  1323.   }
  1324.   break;
  1325. case 0xDB: /*       EH? */
  1326.   break;
  1327. case 0xDC: /*       CALL C,n16 */
  1328.  
  1329.   if (Regs.b.F & FLAG_C)
  1330.   {
  1331.     register UINT16 PC;
  1332.     PC = mem_ReadWord (Regs.w.PC);
  1333.     Regs.w.PC += 2;
  1334.  
  1335.     Regs.w.SP -= 2;
  1336.     mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1337.     Regs.w.PC = PC;
  1338.     ICycles += 12;
  1339.   }
  1340.   else
  1341.   {
  1342.     Regs.w.PC += 2;
  1343.   }
  1344.   break;
  1345. case 0xDD: /*       EH? */
  1346.   break;
  1347. case 0xDE: /*       SBC A,n8 */
  1348.  
  1349.   x = mem_ReadByte (Regs.w.PC++);
  1350.   SBC_A_X (x)
  1351.   break;
  1352. case 0xDF: /*       RST       $18 */
  1353.  
  1354.   Regs.w.SP -= 2;
  1355.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1356.   Regs.w.PC = 0x18;
  1357.   break;
  1358. case 0xE0: /*       LD       ($FF00+n8),A */
  1359.   mem_WriteByte (mem_ReadByte (Regs.w.PC++) + 0xFF00, Regs.b.A);
  1360.   break;
  1361. case 0xE1: /*       POP HL */
  1362.  
  1363.   Regs.w.HL = mem_ReadWord (Regs.w.SP);
  1364.   Regs.w.SP += 2;
  1365.   break;
  1366. case 0xE2: /*       LD ($FF00+C),A */
  1367.  
  1368.   mem_WriteByte ((UINT16) (0xFF00 + Regs.b.C), Regs.b.A);
  1369.   break;
  1370. case 0xE3: /*       EH? */
  1371.   break;
  1372. case 0xE4: /*       EH? */
  1373.   break;
  1374. case 0xE5: /*       PUSH HL */
  1375.  
  1376.   Regs.w.SP -= 2;
  1377.   mem_WriteWord (Regs.w.SP, Regs.w.HL);
  1378.   break;
  1379. case 0xE6: /*       AND A,n8 */
  1380.  
  1381.   x = mem_ReadByte (Regs.w.PC++);
  1382.   AND_A_X (x)
  1383.   break;
  1384. case 0xE7: /*       RST $20 */
  1385.  
  1386.   Regs.w.SP -= 2;
  1387.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1388.   Regs.w.PC = 0x20;
  1389.   break;
  1390. case 0xE8: /*       ADD SP,n8 */
  1391. /*
  1392.  *     Z - Reset.
  1393.  *     N - Reset.
  1394.  *     H - Set or reset according to operation.
  1395.  *     C - Set or reset according to operation.
  1396.  */
  1397.  
  1398.   {
  1399.     register INT32 n;
  1400.     register UINT32 r1, r2;
  1401.     register UINT8 f;
  1402.  
  1403.     /* printf( "Hmmm.. ADD SP,n8\n" ); */
  1404.  
  1405.     n = (INT32) ((INT8) mem_ReadByte (Regs.w.PC++));
  1406.     r1 = Regs.w.SP + n;
  1407.     r2 = (Regs.w.SP & 0xFFF) + (n & 0xFFF);
  1408.  
  1409.     if (r1 > 0xFFFF)
  1410.     {
  1411.       f = FLAG_C;
  1412.     }
  1413.     else
  1414.     {
  1415.       f = 0;
  1416.     }
  1417.  
  1418.     if (r2 > 0xFFF)
  1419.     {
  1420.       f |= FLAG_H;
  1421.     }
  1422.  
  1423.     Regs.w.SP = (UINT16) r1;
  1424.     Regs.b.F = f;
  1425.   }
  1426.   break;
  1427. case 0xE9: /*       JP (HL) */
  1428.  
  1429.   Regs.w.PC = Regs.w.HL;
  1430.   break;
  1431. case 0xEA: /*       LD (n16),A */
  1432.  
  1433.   mem_WriteByte (mem_ReadWord (Regs.w.PC), Regs.b.A);
  1434.   Regs.w.PC += 2;
  1435.   break;
  1436. case 0xEB: /*       EH? */
  1437.   break;
  1438. case 0xEC: /*       EH? */
  1439.   break;
  1440. case 0xED: /*       EH? */
  1441.   break;
  1442. case 0xEE: /*       XOR A,n8 */
  1443.  
  1444.   x = mem_ReadByte (Regs.w.PC++);
  1445.   XOR_A_X (x)
  1446.   break;
  1447. case 0xEF: /*       RST $28 */
  1448.  
  1449.   Regs.w.SP -= 2;
  1450.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1451.   Regs.w.PC = 0x28;
  1452.   break;
  1453. case 0xF0: /*       LD A,($FF00+n8) */
  1454.  
  1455.   Regs.b.A = mem_ReadByte (0xFF00 + mem_ReadByte (Regs.w.PC++));
  1456.   break;
  1457. case 0xF1: /*       POP AF */
  1458.  
  1459.   Regs.w.AF = (UINT16) (mem_ReadWord (Regs.w.SP) & 0xFFF0);
  1460.   Regs.w.SP += 2;
  1461.   break;
  1462. case 0xF2: /*       LD A,($FF00+C) */
  1463.  
  1464.   Regs.b.A = mem_ReadByte ((UINT16) (0xFF00 + Regs.b.C));
  1465.   break;
  1466. case 0xF3: /*       DI */
  1467.  
  1468.   Regs.w.enable &= ~IME;
  1469.   break;
  1470. case 0xF4: /*       EH? */
  1471.   break;
  1472. case 0xF5: /*       PUSH AF */
  1473.  
  1474.   Regs.w.SP -= 2;
  1475.   mem_WriteWord (Regs.w.SP, (UINT16) (Regs.w.AF & 0xFFF0));
  1476.   break;
  1477. case 0xF6: /*       OR A,n8 */
  1478.  
  1479.   x = mem_ReadByte (Regs.w.PC++);
  1480.   OR_A_X (x)
  1481.   break;
  1482. case 0xF7: /*       RST $30 */
  1483.  
  1484.   Regs.w.SP -= 2;
  1485.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1486.   Regs.w.PC = 0x30;
  1487.   break;
  1488. case 0xF8: /*       LD HL,SP+n8 */
  1489. /*
  1490.  *     n = one UINT8 signed immediate value.
  1491.  * Flags affected:
  1492.  *     Z - Reset.
  1493.  *     N - Reset.
  1494.  *     H - Set or reset according to operation.
  1495.  *     C - Set or reset according to operation.
  1496.  *
  1497.  */
  1498.  
  1499.   {
  1500.     register INT32 n;
  1501.     register UINT32 r1, r2;
  1502.     register UINT8 f;
  1503.  
  1504.     n = (INT32) ((INT8) mem_ReadByte (Regs.w.PC++));
  1505.     r1 = Regs.w.SP + n;
  1506.     r2 = (Regs.w.SP & 0xFFF) + (n & 0xFFF);
  1507.  
  1508.     if (r1 > 0xFFFF)
  1509.     {
  1510.       f = FLAG_C;
  1511.     }
  1512.     else
  1513.     {
  1514.       f = 0;
  1515.     }
  1516.  
  1517.     if (r2 > 0xFFF)
  1518.     {
  1519.       f |= FLAG_H;
  1520.     }
  1521.  
  1522.     Regs.w.HL = (UINT16) r1;
  1523.     Regs.b.F = f;
  1524.   }
  1525.   break;
  1526. case 0xF9: /*       LD SP,HL */
  1527.  
  1528.   Regs.w.SP = Regs.w.HL;
  1529.   break;
  1530. case 0xFA: /*       LD A,(n16) */
  1531.  
  1532.   Regs.b.A = mem_ReadByte (mem_ReadWord (Regs.w.PC));
  1533.   Regs.w.PC += 2;
  1534.   break;
  1535. case 0xFB: /*       EI */
  1536.  
  1537.   Regs.w.enable |= IME;
  1538.   CheckInterrupts = 1;
  1539.   break;
  1540. case 0xFC: /*       EH? */
  1541.   break;
  1542. case 0xFD: /*       EH? */
  1543.   break;
  1544. case 0xFE: /*       CP A,n8 */
  1545.  
  1546.   x = mem_ReadByte (Regs.w.PC++);
  1547.   CP_A_X (x)
  1548.   break;
  1549. case 0xFF: /*       RST $38 */
  1550.  
  1551.   Regs.w.SP -= 2;
  1552.   mem_WriteWord (Regs.w.SP, Regs.w.PC);
  1553.   Regs.w.PC = 0x38;
  1554.   break;
  1555.